package com.atguigu.lambda;

import cn.hutool.core.lang.Console;

import java.util.ArrayList;
import java.util.function.BiFunction;
import java.util.function.Predicate;

/**
 * @author Jungle
 * @create 2024-01-06 10:47
 */
// 函数式接口：只要是函数式接口就可以用lambda表达式简化
// 函数式接口 ：接口中有且只有一个未实现的方法，这个接口就叫函数式接口

interface MyInterface {
    int sum(int i, int j);
}

@FunctionalInterface  //检查注解，帮我们快速检查接口是否是函数式接口
interface MyHaha {
    int haha();
    // 有且只有一个抽象方法才可以用lambda表达式
    // int heehe(String string);

    // 接口支持默认实现
    default int heeh(int i) {
        return 2;
    }

}

interface MyHehe {
    int hehe(int i);

}

// 1、自己写实现类
class MyInterfaceImpl implements MyInterface {

    @Override
    public int sum(int i, int j) {
        return i + j;
    }
}

//总结:
//1、Lambda表达式:（参数表)->{方法体}
//2、分辨出你的接口是否函数式接口。函数式接口就可以lambda简化
public class Lambda {

    public static void main(String[] args) {
        var names = new ArrayList<String>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");

        // Collections.sort(names, new Comparator<String>() {
        //     @Override
        //     public int compare(String o1, String o2) {
        //         return o2.compareTo(o1);
        //     }
        // });
        //类:∵方法;引用类中的实例方法  默认比较方式 ，如果要倒序则无法方法引用
        names.sort((String::compareTo));
        names.sort(((o1, o2) -> o2.compareTo(o1))); //倒序只能用这个

        names.forEach(System.out::println);

        // 定义函数
        BiFunction<String, String, String> function = String::concat;
        System.out.println(function.apply("张三", "李四"));


        Predicate<Long> predicate = x -> x > 10;
        // 正向判断 满足的true，不满足的false
        boolean test = predicate.test(5L);


        // 反向判断  不满足的true 满足的false
        boolean test1 = predicate.negate().test(5L);
        Console.log(test,test1);


    }


    /**
     * lambda简化函数式接口创建
     */
    public static void lambda(String[] args) {
        // 1、自己创建实现类对象
        MyInterface myInterface = new MyInterfaceImpl();
        System.out.println(myInterface.sum(1, 2));
        // 2、创建匿名实现类
        MyInterface myInterface1 = new MyInterface() {
            @Override
            public int sum(int i, int j) {
                return i * i + j * j;
            }
        };

        System.out.println(myInterface1.sum(2, 3));
        //    冗余写法
        // 3 lambda表达式  参数列表+箭头+方法体
        MyInterface myInterface2 = (int i, int j) -> {
            return i * i + j * j;
        };
        System.out.println(myInterface2.sum(3, 4));

        //完整写法如上:
        //简化写法:
        //1)、参数类型可以不写，只写(参数名)，参数变量名随意定义;
        // 参数表最少可以只有一个()，或者只有一个参数名;
        // 2、方法体如果只有一句话，(可以省略

        MyHaha haha = () -> 1;
        System.out.println(haha.haha());

        MyHehe hehe = x -> x * x;
        System.out.println(hehe.hehe(10));
    }
}
